AEON MERX LIBRERÍAS ÚTILES EN PYTHON

PANDAS

In [2]:
# importar las librerías necesarias
import pandas as pd
import matplotlib.pyplot as plt
 
# crear el dataframe de ejemplo
datos = {'nombre': ['Ana', 'Carlos', 'Luis', 'María', 'Pedro', 'Sofía', 'Pablo', 'Lucía', 'Diego', 'Valeria'],
         'ciudad': ['Madrid', 'Barcelona','Valencia', 'Sevilla', 'Málaga', 'Bilbao', 'Murcia', 'Alicante', 'Córdoba', 'Valladolid'],
         'presupuesto': [500, 750, 1000, 1250, 1500, 2000, 2500, 3000, 3500, 4000]}
usuarios_df = pd.DataFrame(datos)
 
# imprimir el dataframe
print(usuarios_df)
 
# graficar los resultados
plt.bar(usuarios_df['nombre'], usuarios_df['presupuesto'])
plt.title('Presupuestos de los usuarios')
plt.xlabel('Usuarios')
plt.ylabel('Presupuesto')
plt.show()

    nombre      ciudad  presupuesto
0      Ana      Madrid          500
1   Carlos   Barcelona          750
2     Luis    Valencia         1000
3    María     Sevilla         1250
4    Pedro      Málaga         1500
5    Sofía      Bilbao         2000
6    Pablo      Murcia         2500
7    Lucía    Alicante         3000
8    Diego     Córdoba         3500
9  Valeria  Valladolid         4000

USANDO SEABORN

In [3]:
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

# Creamos los datos
x = [1, 2, 3, 4, 5, 6, 7]
y = [10, 5, 8, 7, 2, 6, 4]

# Creamos el dataframe con los datos
df = pd.DataFrame({'x': x, 'y': y})

# Utilizamos Seaborn para el gráfico de dispersión
sns.scatterplot(data=df, x='x', y='y')

# Añadimos un título
plt.title('Gráfico de dispersión utilizando Seaborn')

# Mostramos el gráfico
plt.show()

PLOTLY

Este código genera una gráfica de la función coseno entre 0 y 2π. Puedes cambiar la función a graficar y ajustar la configuración de la gráfica según tus necesidades.

In [4]:
import plotly.graph_objs as go
import numpy as np

# Definimos la función que queremos graficar
def funcion(x):
    return np.cos(x)

# Generamos los puntos para la gráfica
x = np.linspace(0, 2*np.pi, 200)
y = funcion(x)

# Creamos la figura
fig = go.Figure()


# Agregamos la línea correspondiente a la función
fig.add_trace(go.Scatter(x=x, y=y, name='Función coseno'))

# Configuramos los ejes y el título de la gráfica
fig.update_layout(
    xaxis_title = 'Eje x',
    yaxis_title = 'Eje y',
    title={
            'text': 'Gráfica de la función coseno',
            'y':0.9,
            'x':0.5,
            'xanchor': 'center',
            'yanchor': 'top'}
)

# Mostramos la gráfica
fig.show()

LIBRERÍA BOKEH

La librería Bokeh puede ser utilizada para crear visualizaciones interactivas.
Por ejemplo, se podría crear un gráfico de dispersión interactivo que muestre la relación entre la temperatura y la precipitación en diferentes ciudades a lo largo de un período de tiempo. El usuario podría hacer clic en puntos individuales para ver más información sobre cada ciudad, como la población y el clima promedio. También se podría crear un mapa interactivo que muestre la ubicación de las tiendas de una cadena de tiendas en todo el país, permitiendo al usuario filtrar por ubicación y ver detalles específicos de cada tienda.

Este código creará un gráfico con una línea y puntos dibujados en él, y lo guardará en un archivo HTML llamado "grafico.html", que se abrirá automáticamente en tu navegador predeterminado. Sin embargo, hay muchas más características y opciones que puedes utilizar con la librería Bokeh para crear gráficos más complejos y personalizados.

In [5]:
from bokeh.plotting import figure, output_file, show

# Crear una lista de datos
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]

# Crear una figura con título y etiquetas de eje
fig = figure(title="Ejemplo de gráfico de Bokeh", x_axis_label='X', y_axis_label='Y')

# Agregar datos a la figura
fig.line(x, y, legend_label="Linea", line_width=2)
fig.circle(x, y, legend_label="Puntos", size=10)

# Definir la salida del gráfico a un archivo HTML
output_file("grafico.html")

# Mostrar el gráfico
show(fig)
# al ejecutar este codigo se abrirá el navegador mostrando el gráfico en un HTML

ALTAIR

Este ejemplo utiliza datos de automóviles de la librería vega_datasets. Estos datos se representan gráficamente en cuatro gráficos de dispersión, cada uno con una variable diferente en el eje x y la eficiencia de combustible en el eje y. La interacción entre estos gráficos está habilitada por la selección de intervalos, lo que permite al usuario seleccionar subconjuntos específicos de los datos y analizarlos en detalle.

In [6]:
import altair as alt
from vega_datasets import data

source = data.cars()

chart = alt.Chart(source).mark_point().encode(
    x='Horsepower',
    y='Miles_per_Gallon',
    color='Origin',
)

# Mostrar el gráfico utilizando display
display(chart)

SCIPY

In [7]:
import scipy.integrate as spi
def f(x):
    return x**2 + 3*x + 2 
result, error = spi.quad(f, 0, 2) 
print("El valor de la integral es:", result)

El valor de la integral es: 12.666666666666666

ALGEBRA LINEAL

Queremos resolver el siguiente sistema de ecuaciones lineales:

7 x + y - z = 1
x - y + z = 2
3x + 2y + z = 3

Podemos utilizar la función solve() de la subbiblioteca scipy.linalg de la siguiente manera:¶

In [12]:
import numpy as np
import scipy.linalg as la

A = np.array([[7, 1, -1], [1, -1, 1], [3, 2, 1]])
b = np.array([1, 2, 3])

x = la.solve(A, b)

print("La solución del sistema es:",x)

La solución del sistema es: [0.375      0.08333333 1.70833333]

PROCESAMIENTO DE SEÑALES

Supongamos que queremos generar una señal sinusoidal de amplitud 1, frecuencia 5 Hz y duración 1 segundo. Podemos utilizar la función linspace() de NumPy para generar un vector de tiempo y luego utilizar la función sin() para generar la señal:

In [10]:
import numpy as np
import matplotlib.pyplot as plt
import scipy.signal as sig

# Generar el vector de tiempo
fs = 1000
t = np.linspace(0, 1, fs)

# Generar la señal sinusoidal
f = 5
x = np.sin(2 * np.pi * f * t)

# Graficar la señal
plt.plot(t, x)
plt.xlabel("Tiempo (s)")
plt.ylabel("Amplitud")
plt.show()

SymPy

In [20]:
from sympy import *
a = Rational(1,2)
print(a)
print(a*2)
print(pi**2)
print(pi**2)
print(pi.evalf())
print((pi+exp(1)).evalf())
print(oo) 
print(oo + 1)

1/2
1
pi**2
pi**2
3.14159265358979
5.85987448204884
oo
oo

SIMBOLOS

In [21]:
x = Symbol('x')
y = Symbol('y')
In [22]:
x+y+x-y
Out[22]:
$\displaystyle 2 x$

MANIPULACIONES ALGEBRÁICAS

SymPy es capaz de ejecutar potentes manipulaciones algebráicas. Echaremos un vistazo a algunas de las más usadas: expandir y simplificar.

EXPANDIR

In [24]:
#expandir
expand((x+y)**3)
Out[24]:
$\displaystyle x^{3} + 3 x^{2} y + 3 x y^{2} + y^{3}$
In [27]:
expand(x+y, complex=True)
Out[27]:
$\displaystyle \operatorname{re}{\left(x\right)} + \operatorname{re}{\left(y\right)} + i \operatorname{im}{\left(x\right)} + i \operatorname{im}{\left(y\right)}$
In [26]:
expand(cos(x+y), trig=True)
Out[26]:
$\displaystyle - \sin{\left(x \right)} \sin{\left(y \right)} + \cos{\left(x \right)} \cos{\left(y \right)}$

SIMPLIFICAR

In [41]:
#sIMPLIFICAR UNA EXPRESIÓN ALGEBRAICA
simplify((x+x*y)/x)
Out[41]:
$\displaystyle y + 1$

Simplificación es un término vago, es por ello que existen alternativas más precisas que simplify: powsimp (simplificación de exponentes), trigsimp (para expresiones trigonométricas) , logcombine, radsimp, together.

In [37]:
powsimp((x+x*y))
Out[37]:
$\displaystyle x y + x$
In [38]:
trigsimp((cos(x)+cos(x*y))/cos(x))
Out[38]:
$\displaystyle 1 + \frac{\cos{\left(x y \right)}}{\cos{\left(x \right)}}$
In [39]:
together((x+x*y)/x**2)
Out[39]:
$\displaystyle \frac{y + 1}{x}$

EJERCICIO: PRUEBA los métodos faltantes: Es decir el método logcombine() y el método randsimp()

LIMITES </H1>

SIGUEN LA ESTRUCTURA : -Función -Variable -Punto

In [43]:
limit(sin(x)/x, x, 0)
Out[43]:
$\displaystyle 1$
In [44]:
limit(x, x, oo)
Out[44]:
$\displaystyle \infty$
In [45]:
limit(1/x, x, oo)
Out[45]:
$\displaystyle 0$
In [46]:
limit(x**x, x, 0)
Out[46]:
$\displaystyle 1$

DERIVADAS

Puedes derivar cualquier expresión SymPy usando diff(func, var)

In [47]:
diff(sin(x), x)
Out[47]:
$\displaystyle \cos{\left(x \right)}$
In [48]:
diff(sin(2*x), x)
Out[48]:
$\displaystyle 2 \cos{\left(2 x \right)}$
In [49]:
limit((tan(x+y)-tan(x))/y, y, 0)
Out[49]:
$\displaystyle \tan^{2}{\left(x \right)} + 1$
In [51]:
diff(sin(2*x), x, 1)
Out[51]:
$\displaystyle 2 \cos{\left(2 x \right)}$
In [52]:
diff(sin(2*x), x, 2)
Out[52]:
$\displaystyle - 4 \sin{\left(2 x \right)}$
In [53]:
diff(sin(2*x), x, 3)
Out[53]:
$\displaystyle - 8 \cos{\left(2 x \right)}$

SERIE DE TAYLOR

In [54]:
series(cos(x), x)
Out[54]:
$\displaystyle 1 - \frac{x^{2}}{2} + \frac{x^{4}}{24} + O\left(x^{6}\right)$
In [56]:
series(1/cos(x), x)
Out[56]:
$\displaystyle 1 + \frac{x^{2}}{2} + \frac{5 x^{4}}{24} + O\left(x^{6}\right)$
In [55]:
print(series(1/cos(x), x))

1 + x**2/2 + 5*x**4/24 + O(x**6)

INTEGRALES

SymPy ofrece soporte para integrales definidas o indefinidas de funciones transcendentes elementales y de funciones especiales via integrate(), que usa una potente extensión del algoritmo Risch-Norman y algo de heurística y de reconocimiento de patrones. Puedes integrar funciones elementales de la siguiente forma

In [58]:
integrate(6*x**5, x)
Out[58]:
$\displaystyle x^{6}$
In [59]:
integrate(sin(x), x)
Out[59]:
$\displaystyle - \cos{\left(x \right)}$

También se pueden manejar funciones especiales de forma sencilla

In [61]:
integrate(exp(-x**2)*erf(x), x)
Out[61]:
$\displaystyle \frac{\sqrt{\pi} \operatorname{erf}^{2}{\left(x \right)}}{4}$

Es posible calcular integrales definidas

In [62]:
integrate(x**3, (x, -1, 1))
Out[62]:
$\displaystyle 0$
In [63]:
integrate(sin(x), (x, 0, pi/2))
Out[63]:
$\displaystyle 1$
In [64]:
integrate(exp(-x), (x, 0, oo))
Out[64]:
$\displaystyle 1$
In [ ]:
RESOLUCIÓN DE ECUACIONES
In [65]:
solve(x**4 - 1, x)
Out[65]:
[-1, 1, -I, I]
In [66]:
solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
Out[66]:
{x: -3, y: 1}

RESOLUCIÓN DE ECUACIONES TRASCENDENTALES

In [70]:
solve(exp(x) + 1, x)
Out[70]:
[I*pi]

ECUACIONES POLINÓMICAS

In [71]:
f = x**4 - 3*x**2 + 1
In [72]:
factor(f)
Out[72]:
$\displaystyle \left(x^{2} - x - 1\right) \left(x^{2} + x - 1\right)$
In [74]:
factor(f, modulus=1)
Out[74]:
$\displaystyle 0$
In [75]:
factor(f, modulus=2)
Out[75]:
$\displaystyle \left(x^{2} + x + 1\right)^{2}$
In [76]:
factor(f, modulus=3)
Out[76]:
$\displaystyle \left(x^{2} - x - 1\right) \left(x^{2} + x - 1\right)$
In [78]:
satisfiable(x & y)
Out[78]:
{y: True, x: True}
In [79]:
satisfiable(x & ~x)
Out[79]:
False

ALGEBRA LINEAL

In [80]:
from sympy import Matrix
Matrix([[1,0], [0,1]])
Out[80]:
$\displaystyle \left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right]$

A diferencia de un NumPy array, en una matriz (de Sympy) se pueden incluir también símbolos

In [81]:
x = Symbol('x')
y = Symbol('y')
A = Matrix([[1,x], [y,1]])
A
Out[81]:
$\displaystyle \left[\begin{matrix}1 & x\\y & 1\end{matrix}\right]$
In [105]:
import sympy as sym
import numpy as np
t = symbols('t')
x = Function('x')(t)
y = Function('y')(t)
solucion = dsolve([x.diff() - y, y.diff() + x])
print(solucion)

[Eq(x(t), C1*sin(t) + C2*cos(t)), Eq(y(t), C1*cos(t) - C2*sin(t))]

EJERCICIO: EJECUTA EL SIGUIENTE CÓDIGO Y HAZ UN ENSAYO QUE EXPLIQUE SUS PARTES ENVIALO A development@aeonmerx.com con tu nombre en el ASUNTO PARA OBTENER UNA MASTER CLASS GRATUITA

ENTRENAR LÓGICA DE PROGRAMACIÓN EN PYTHON USANDO CICLOS Y LISTAS

In [1]:
def imprimir_materias_suspendidas(calificaciones):
    calificacion_aprobatoria = 7
    asignaturas_suspendidas = {}
    for alumno in calificaciones:
        for asignatura_con_calificacion in calificaciones[alumno]:
            asignatura = asignatura_con_calificacion["asignatura"]
            calificacion = asignatura_con_calificacion["calificacion"]
            if asignatura not in asignaturas_suspendidas:
                asignaturas_suspendidas[asignatura] = 0
            if calificacion < calificacion_aprobatoria:
                asignaturas_suspendidas[asignatura] += 1

    for asignatura_suspendida in asignaturas_suspendidas:
        conteo = asignaturas_suspendidas[asignatura_suspendida]
        print(f"{asignatura_suspendida} perdida por {conteo} alumno(s)")


def obtener_alumnos_con_media(calificaciones):
    sumatorias = {}
    for alumno in calificaciones:
        for asignatura_con_calificacion in calificaciones[alumno]:
            calificacion = asignatura_con_calificacion["calificacion"]
            if alumno not in sumatorias:
                sumatorias[alumno] = {"sumatoria": 0, "conteo": 0}
            sumatorias[alumno]["sumatoria"] += calificacion
            sumatorias[alumno]["conteo"] += 1

    return sumatorias


def imprimir_media(calificaciones):
    sumatorias = obtener_alumnos_con_media(calificaciones)
    for alumno in sumatorias:
        sumatoria = sumatorias[alumno]["sumatoria"]
        conteo = sumatorias[alumno]["conteo"]
        media = sumatoria/conteo
        print(f"{alumno} media de {media}")


def imprimir_media_nota_superior_5(calificaciones):
    sumatorias = obtener_alumnos_con_media(calificaciones)
    media_minima = 5
    for alumno in sumatorias:
        sumatoria = sumatorias[alumno]["sumatoria"]
        conteo = sumatorias[alumno]["conteo"]
        media = sumatoria/conteo
        if media > media_minima:
            print(f"{alumno} tuvo una media superior a {media_minima} ({media})")


def main():
    calificaciones = {
        "Alumno 1": [{"asignatura": "Latin", "calificacion": 8}, {"asignatura": "Castellano", "calificacion": 8}, {"asignatura": "Francés", "calificacion": 9}, {"asignatura": "Inglés", "calificacion": 4}],
        "Alumno 2": [{"asignatura": "Latin", "calificacion": 7}, {"asignatura": "Castellano", "calificacion": 6}, {"asignatura": "Francés", "calificacion": 7}, {"asignatura": "Inglés", "calificacion": 2}],
        "Alumno 3": [{"asignatura": "Latin", "calificacion": 10}, {"asignatura": "Castellano", "calificacion": 7}, {"asignatura": "Francés", "calificacion": 8}, {"asignatura": "Inglés", "calificacion": 9}],
        "Alumno 4": [{"asignatura": "Latin", "calificacion": 4}, {"asignatura": "Castellano", "calificacion": 4}, {"asignatura": "Francés", "calificacion": 3}, {"asignatura": "Inglés", "calificacion": 2}],
        "Alumno 5": [{"asignatura": "Latin", "calificacion": 9}, {"asignatura": "Castellano", "calificacion": 8}, {"asignatura": "Francés", "calificacion": 9}, {"asignatura": "Inglés", "calificacion": 6}],
    }
    imprimir_materias_suspendidas(calificaciones)
    imprimir_media(calificaciones)
    imprimir_media_nota_superior_5(calificaciones)


main()

Latin perdida por 1 alumno(s)
Castellano perdida por 2 alumno(s)
Francés perdida por 1 alumno(s)
Inglés perdida por 4 alumno(s)
Alumno 1 media de 7.25
Alumno 2 media de 5.5
Alumno 3 media de 8.5
Alumno 4 media de 3.25
Alumno 5 media de 8.0
Alumno 1 tuvo una media superior a 5 (7.25)
Alumno 2 tuvo una media superior a 5 (5.5)
Alumno 3 tuvo una media superior a 5 (8.5)
Alumno 5 tuvo una media superior a 5 (8.0)

AEON MERX 2023

In [ ]: